home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_10_08 / qcdemow.cpp < prev    next >
C/C++ Source or Header  |  1992-07-20  |  22KB  |  631 lines
  1. ///////////////////////////////////////////////////////
  2. //  QCDEMOW.CPP: Quadcode demo program for Windows
  3. //  Written by:
  4. //    Kenneth Van Camp
  5. //    RR #1 Box 1255
  6. //    East Stroudsburg, PA  18301
  7. //    (717)223-8620
  8. //
  9. //  Functions -
  10. //    main                      main pgm entry point
  11. //    init_graphics             initialize graphics
  12. //    Cursor::Cursor            default constructor
  13. //    Cursor::Move              move cursor
  14. //    RegionDisplay::Display    display region
  15. //    RegionDisplay::Interact   user interaction
  16. //    win_yieldfunc             yield function for build
  17. //
  18. ///////////////////////////////////////////////////////
  19. #include <windows.h>
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <ctype.h>
  23. #include <string.h>
  24. #include <time.h>
  25. #include <iostream.h>
  26. #include "qc.h"
  27. #include "qcdemow.h"
  28.  
  29. // Global variables:
  30. HCURSOR ArrowCursor,        //  standard arrow cursor
  31.         WaitCursor;         //  hourglass cursor
  32. HDC     Hdc;                //  device context for the window
  33. HWND    BuildHdlg,          //  handle for the Building dialog box
  34.         MainHwnd;           //  handle for application's main window
  35. HANDLE  Haccel;             //  handle for application acclerators
  36. int     Shrink = TRUE,      //  shrink all qc's for plotting?
  37.         XShrinkage = 0,     //  amount to shrink in X direction
  38.         YShrinkage = 0,     //  amount to shrink in Y direction
  39.         Xmax = 0,           //  # pixels in viewport in X direction
  40.         Ymax = 0,           //  # pixels in viewport in Y direction
  41.         QCsize,             //  size of a single-division quadcode
  42.         Nquits,             //  number of quits used to represent region
  43.         RegionNumQC = 0,    //  number of qc's in region
  44.         BuildCancelled = FALSE; //  was the region building cancelled?
  45. time_t  RegionBuildTime = 0;//  time to build region
  46.  
  47. const int   SCRRES = 1024;  //  screen resolution used (logical coords)
  48.  
  49. // class RegionDisplay: A Region class with graphical
  50. // display and interaction capabilities.
  51. class RegionDisplay: public Region
  52. {
  53.   public:
  54.     RegionDisplay         // constructor from outline
  55.         (PointListHeader &vertex_list):
  56.         Region (vertex_list) { }  // calls base constr.
  57.     void Display (void);  // display on graphics screen
  58.     void Interact (void); // graphic interact function
  59. };  // class RegionDisplay
  60.  
  61. RegionDisplay *TheRegion = NULL;
  62.  
  63. // The following is the perimeter list for the demo region:
  64. const int Npts = 37;
  65. const int Ndiv = 128;
  66. const int Reduce = 1;
  67. Point Plist[Npts] =
  68. {
  69.     {  5, 68}, { 28, 68}, { 32, 88}, { 33, 94},
  70.     { 31,110}, { 30,113}, { 35,124}, { 51,125},
  71.     { 63,127}, { 63,119}, { 67,116}, { 59,109},
  72.     { 63,119}, { 63,127}, { 74,126}, { 80,125},
  73.     { 88,112}, { 99,101}, {107, 98}, {113, 96},
  74.     {124, 98}, {122, 94}, {123, 91}, {121, 85},
  75.     {118, 78}, {108, 73}, { 96, 64}, { 85, 58},
  76.     { 81, 50}, { 82, 46}, { 90, 38}, { 83, 25},
  77.     { 72, 21}, { 58,  8}, { 55,  8}, { 54, 40},
  78.     {  5, 40}, 
  79. };
  80. PointListHeader Phdr =
  81. {
  82.     Npts, Ndiv, Plist
  83. };
  84.  
  85.  
  86. // Prototypes for exported functions:
  87.  
  88. #if defined( __cplusplus )
  89. extern "C" {
  90. #endif  // __cplusplus
  91.  
  92. long FAR PASCAL WndProc (HWND, UINT, WPARAM, LPARAM);
  93. BOOL FAR PASCAL AboutDlgProc (HWND, UINT, WPARAM, LPARAM);
  94. BOOL FAR PASCAL BuildDlgProc (HWND, UINT, WPARAM, LPARAM);
  95.  
  96. #if defined( __cplusplus )
  97. }
  98. #endif  // __cplusplus
  99.  
  100. // Prototypes for other local functions:
  101. void redraw_win (int first_time);
  102. void update_status (int xcursor, int ycursor);
  103. void set_draw_area (void);
  104. int win_yieldfunc (int pct_complete);
  105.  
  106. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  107.                     LPSTR lpszCmdParam, int nCmdShow)
  108. {
  109.     static char szAppName[] = "QCDemoW";
  110.     MSG         msg;
  111.     WNDCLASS    wndclass;
  112.  
  113.     // Initialize the cursor we will use.
  114.     ArrowCursor = LoadCursor (NULL, IDC_ARROW);
  115.     WaitCursor  = LoadCursor (NULL, IDC_WAIT);
  116.  
  117.     if (!hPrevInstance)
  118.     {
  119.         wndclass.style         = CS_HREDRAW | CS_VREDRAW;
  120.         wndclass.lpfnWndProc   = WndProc;
  121.         wndclass.cbClsExtra    = 0;
  122.         wndclass.cbWndExtra    = 0;
  123.         wndclass.hInstance     = hInstance;
  124.         wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
  125.         wndclass.hCursor       = ArrowCursor;
  126.         wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  127.         wndclass.lpszMenuName  = "QCDEMOW";
  128.         wndclass.lpszClassName = szAppName;
  129.  
  130.         RegisterClass (&wndclass);
  131.     }
  132.  
  133.     MainHwnd = CreateWindow (szAppName, // window class name
  134.             "Quadcode Demo (Windows Version)",  // window caption
  135.             WS_OVERLAPPEDWINDOW,    // window style
  136.             CW_USEDEFAULT,          // initial x position
  137.             CW_USEDEFAULT,          // initial y position
  138.             CW_USEDEFAULT,          // initial x size
  139.             CW_USEDEFAULT,          // initial y size
  140.             NULL,                   // parent window handle
  141.             NULL,                   // window menu handle
  142.             hInstance,              // program instance handle
  143.             NULL);                  // creation parameters
  144.  
  145.     ShowWindow (MainHwnd, nCmdShow);
  146.     UpdateWindow (MainHwnd);
  147.  
  148.     Haccel = LoadAccelerators (hInstance, "ACCELERATORS_1");
  149.     if (Haccel == NULL)
  150.         MessageBox (MainHwnd, "Can't Load Acelerators", "NOTICE",
  151.                             MB_ICONEXCLAMATION | MB_OK);
  152.  
  153.     while (GetMessage (&msg, NULL, 0, 0))
  154.     {
  155.         // Translate accelerator keystrokes, too.
  156.         if (! TranslateAccelerator (MainHwnd, Haccel, &msg))
  157.         {
  158.             TranslateMessage (&msg);
  159.             DispatchMessage (&msg);
  160.         }
  161.     }
  162.     return msg.wParam;
  163.  
  164. }   // WinMain
  165.  
  166. long FAR PASCAL WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
  167. {
  168.     PAINTSTRUCT ps;
  169.     int         ret;
  170.     WORD        menu_state;         // Current menu state (checked or not)
  171.     char        tmpstr[80];
  172.  
  173.     static int      first_paint = TRUE, // Is this the first screen paint?
  174.                     resized = FALSE;    // Was the window just resized?
  175.     static HMENU    menu;           // Popup menu
  176.     static HANDLE   hinstance;      // Instance of this program
  177.     static FARPROC  about_dlg_proc, // Point to About dialog box procedure
  178.                     build_dlg_proc; // Point to Build dialog box procedure
  179.  
  180.     switch (message)
  181.     {
  182.         case WM_CREATE:
  183.             // This occurs when the window is first created.
  184.             // First get the instance of the main program.
  185.             hinstance = ((LPCREATESTRUCT)lParam)->hInstance;
  186.             // Register the dialog procedures:
  187.             about_dlg_proc = MakeProcInstance ((FARPROC)AboutDlgProc,
  188.                         hinstance);
  189.             build_dlg_proc = MakeProcInstance ((FARPROC)BuildDlgProc,
  190.                         hinstance);
  191.             // Then get the handle for the menu
  192.             menu = GetMenu (hwnd);
  193.             return 0;
  194.  
  195.         case WM_COMMAND:
  196.             // This is a menu selection or accelerator.
  197.             // Ignore any menu commands if the region is not built yet.
  198.             if (RegionNumQC == 0)
  199.                 return 0;
  200.             switch ( wParam )
  201.             {
  202.                 case QCMNU_EXIT:   // File Menu, Exit QCDemoW selection
  203.                 case QCACC_EXIT:   // Alt-X accelerator
  204.                     ret = MessageBox (hwnd, "Are You Sure You Want To Exit?",
  205.                             "QCDemoW", MB_OKCANCEL);
  206.                     if ( ret == IDOK )
  207.                         PostQuitMessage (0);
  208.                     return 0;
  209.  
  210.                 case QCMNU_ABOUT:   // File Menu, About selection
  211.                     DialogBox (hinstance, "ABOUT_BOX", hwnd, about_dlg_proc);
  212.                     return 0;
  213.  
  214.                 case QCMNU_SHRINKAGE:   // Options Menu, Shrinkage selection
  215.                 case QCACC_SHRINKAGE:   // Alt-S accelerator
  216.                     // This is a boolean checked item: Reverse previous state.
  217.                     if (Shrink)